import { constantRoutes } from "@/router";
import { getRouters, getRofenye } from "@/api/menu";
import Layout from "@/layout/index";
import ParentView from "@/components/ParentView";
import InnerLink from "@/layout/components/InnerLink";

const permission = {
    state: {
        routes: [],
        addRoutes: [],
        defaultRoutes: [],
        topbarRouters: [],
        sidebarRouters: [],
    },
    mutations: {
        SET_ROUTES: (state, routes) => {
            console.log(state, routes, "state, routes");
            state.addRoutes = routes;
            state.routes = constantRoutes.concat(routes);
            console.log(state.routes, "state.routes");
        },
        SET_DEFAULT_ROUTES: (state, routes) => {
            state.defaultRoutes = constantRoutes.concat(routes);
        },
        SET_TOPBAR_ROUTES: (state, routes) => {
            // 顶部导航菜单默认添加统计报表栏指向首页
            const index = [{
                path: "index",
                meta: { title: "统计报表", icon: "dashboard" },
            }, ];
            console.log(index, 'index')
            state.topbarRouters = routes.concat(index);
        },
        SET_SIDEBAR_ROUTERS: (state, routes) => {
            state.sidebarRouters = routes;
        },
    },
    actions: {
        // 生成路由
        GenerateRoutes({ commit }) {
            console.log(commit, "commit");
            return new Promise((resolve) => {
                console.log(resolve, "Aa");
                // 向后端请求路由数据
                getRouters().then((res) => {

                    let routeTree = []
                    let sencond = res.data.role[0].menu.filter(route => {
                        if (route.parentId == 0) {
                            route.children = []
                            route.component = 'Layout' //后端返回，到时候去掉（一级页面填Layout，后面的页面填该页面@/views后面的路径）
                            route.alwaysShow = true // 后端返回，当你一个路由下面的 children 声明的路由大于1个时，自动会变成嵌套的模式--如组件页面
                            route.meta = { //最好由后端返回，到时候去掉
                                icon: "", //一级文字前面的图标
                                noCache: false, //是否缓存
                                title: route.name //标题
                            }
                            routeTree.push(route)
                            return false
                        }
                        return true
                    })
                    console.log(routeTree, 'routeTree')
                    let third = sencond.filter(route => {
                        if (route.parentId != 0) {
                            routeTree.forEach(levelOneRoute => {
                                if (levelOneRoute.id == route.parentId) {
                                    route.children = []
                                    route.component = 'system/role/authUser'
                                    route.alwaysShow = false
                                    route.meta = {
                                        icon: "", //二级图标
                                        noCache: false,
                                        title: route.name
                                    }
                                    levelOneRoute.alwaysShow = true
                                    levelOneRoute.children.push(route)
                                    return false
                                }
                            })
                        }
                        return true
                    })
                    third.map(route => {
                            routeTree.forEach(levelOneRoute => {
                                levelOneRoute.children.forEach(levelSecondRoute => {
                                    if (levelSecondRoute.id == route.parentId) {
                                        route.children = []
                                        route.component = 'system/role/authUser'
                                        route.alwaysShow = false
                                        route.meta = {
                                            icon: "", //三级图标
                                            noCache: false,
                                            title: route.name
                                        }
                                        levelSecondRoute.alwaysShow = true
                                        levelSecondRoute.children.push(route)
                                        return false
                                    }
                                })
                            })
                        })
                        // console.log(routeTree);
                    const sdata = JSON.parse(JSON.stringify(routeTree));
                    // console.log(sdata);
                    const rdata = JSON.parse(JSON.stringify(routeTree));
                    const sidebarRoutes = filterAsyncRouter(sdata);
                    // console.log(sidebarRoutes);
                    const rewriteRoutes = filterAsyncRouter(rdata, false, true);
                    rewriteRoutes.push({ path: "*", redirect: "/404", hidden: true });
                    commit("SET_ROUTES", rewriteRoutes);
                    commit("SET_SIDEBAR_ROUTERS", constantRoutes.concat(sidebarRoutes));
                    commit("SET_DEFAULT_ROUTES", sidebarRoutes);
                    sidebarRoutes.reverse() //菜单倒叙
                    commit("SET_TOPBAR_ROUTES", sidebarRoutes);
                    resolve(rewriteRoutes);
                });
                getRofenye().then((res) => {
                    console.log(res, '111res')
                })
            });
        },
    },
};

// 遍历后台传来的路由字符串，转换为组件对象
function filterAsyncRouter(asyncRouterMap, lastRouter = false, type = false) {
    console.log(asyncRouterMap.filter);
    return asyncRouterMap.filter((route) => {
        // console.log(route);
        if (type && route.children) {
            route.children = filterChildren(route.children);
        }
        if (route.component) {
            // Layout ParentView 组件特殊处理
            if (route.component === "Layout") {
                route.component = Layout;
            } else if (route.component === "ParentView") {
                route.component = ParentView;
            } else if (route.component === "InnerLink") {
                route.component = InnerLink;
            } else {
                route.component = loadView(route.component);
            }
        }
        if (route.children != null && route.children && route.children.length) {
            route.children = filterAsyncRouter(route.children, route, type);
        } else {
            delete route["children"];
            delete route["redirect"];
        }
        return true;
    });
}

function filterChildren(childrenMap, lastRouter = false) {
    var children = [];
    childrenMap.forEach((el, index) => {
        if (el.children && el.children.length) {
            if (el.component === "ParentView" && !lastRouter) {
                el.children.forEach((c) => {
                    // console.log(c,'c')
                    c.path = el.path + "/" + c.path;
                    if (c.children && c.children.length) {
                        children = children.concat(filterChildren(c.children, c));
                        return;
                    }
                    children.push(c);
                });
                return;
            }
        }
        if (lastRouter) {
            el.path = lastRouter.path + "/" + el.path;
        }
        children = children.concat(el);
    });
    return children;
}

export const loadView = (view) => {
    // console.log(view, "view");
    if (process.env.NODE_ENV === "development") {
        return (resolve) => require([`@/views/${view}`], resolve);
    } else {
        // 使用 import 实现生产环境的路由懒加载
        return () =>
            import (`@/views/${view}`);
    }
};

export default permission; //默认输出permission